module Api
          
        
      
        

          

            

            

              module Admin
          
        
      
        

          

            

            

                class AdminController < ApplicationController
          
        
      
        

          

            

            

                include AdminAuthorizable
          
        
      
        

          

            

            

                before_action :authenticate_admin!
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # GET /api/admin/dashboard
          
        
      
        

          

            

            

                def dashboard
          
        
      
        

          

            

            

                  render json: {
          
        
      
        

          

            

            

                    current_user: {
          
        
      
        

          

            

            

                      id: current_user.id,
          
        
      
        

          

            

            

                      nickname: current_user.nickname,
          
        
      
        

          

            

            

                      role: current_user.role_display_name,
          
        
      
        

          

            

            

                      permissions: current_user_permissions
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    system_stats: {
          
        
      
        

          

            

            

                      total_users: User.count,
          
        
      
        

          

            

            

                      total_posts: Post.count,
          
        
      
        

          

            

            

                      visible_posts: Post.visible.count,
          
        
      
        

          

            

            

                      total_events: ReadingEvent.count,
          
        
      
        

          

            

            

                      pending_events: ReadingEvent.where(approval_status: :pending).count,
          
        
      
        

          

            

            

                      active_events: ReadingEvent.where(status: :in_progress).count,
          
        
      
        

          

            

            

                      admin_count: User.where(role: :admin).count,
          
        
      
        

          

            

            

                      root_count: User.where(role: :root).count
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    available_actions: admin_available_actions
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # GET /api/admin/users
          
        
      
        

          

            

            

                def users
          
        
      
        

          

            

            

                  authenticate_root!  # 只有root可以查看所有用户
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  users = User.select(:id, :nickname, :role, :created_at, :wx_openid)
          
        
      
        

          

            

            

                               .order(created_at: :desc)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  render json: {
          
        
      
        

          

            

            

                    users: users.map { |user|
          
        
      
        

          

            

            

                      {
          
        
      
        

          

            

            

                        id: user.id,
          
        
      
        

          

            

            

                        nickname: user.nickname,
          
        
      
        

          

            

            

                        role: user.role_display_name,
          
        
      
        

          

            

            

                        role_value: user.role,
          
        
      
        

          

            

            

                        created_at: user.created_at,
          
        
      
        

          

            

            

                        permissions: user_permissions_for(user)
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    summary: {
          
        
      
        

          

            

            

                      total: users.count,
          
        
      
        

          

            

            

                      by_role: {
          
        
      
        

          

            

            

                        user: users.select(&:user?).count,
          
        
      
        

          

            

            

                        admin: users.select(&:admin?).count,
          
        
      
        

          

            

            

                        root: users.select(&:root?).count
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # PUT /api/admin/users/:id/promote_admin
          
        
      
        

          

            

            

                def promote_user_to_admin
          
        
      
        

          

            

            

                  authenticate_root!  # 只有root可以提升管理员
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  user = User.find(params[:id])
          
        
      
        

          

            

            

                  if user.root?
          
        
      
        

          

            

            

                    return render json: { error: "不能提升超级管理员" }, status: :unprocessable_entity
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if user.update!(role: :admin)
          
        
      
        

          

            

            

                    render json: {
          
        
      
        

          

            

            

                      message: "用户已提升为管理员",
          
        
      
        

          

            

            

                      user: {
          
        
      
        

          

            

            

                        id: user.id,
          
        
      
        

          

            

            

                        nickname: user.nickname,
          
        
      
        

          

            

            

                        new_role: user.role_display_name
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    render json: { error: "提升失败" }, status: :unprocessable_entity
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # PUT /api/admin/users/:id/demote
          
        
      
        

          

            

            

                def demote_user
          
        
      
        

          

            

            

                  authenticate_root!  # 只有root可以降级用户
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  user = User.find(params[:id])
          
        
      
        

          

            

            

                  if user.root?
          
        
      
        

          

            

            

                    return render json: { error: "不能降级超级管理员" }, status: :unprocessable_entity
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if user.update!(role: :participant)
          
        
      
        

          

            

            

                    render json: {
          
        
      
        

          

            

            

                      message: "用户已降级为参与者",
          
        
      
        

          

            

            

                      user: {
          
        
      
        

          

            

            

                        id: user.id,
          
        
      
        

          

            

            

                        nickname: user.nickname,
          
        
      
        

          

            

            

                        new_role: user.role_display_name
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    render json: { error: "降级失败" }, status: :unprocessable_entity
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # GET /api/admin/events/pending
          
        
      
        

          

            

            

                def pending_events
          
        
      
        

          

            

            

                  events = ReadingEvent.includes(:leader)
          
        
      
        

          

            

            

                                  .where(approval_status: :pending)
          
        
      
        

          

            

            

                                  .order(created_at: :desc)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  render json: {
          
        
      
        

          

            

            

                    events: events.map { |event|
          
        
      
        

          

            

            

                      {
          
        
      
        

          

            

            

                        id: event.id,
          
        
      
        

          

            

            

                        title: event.title,
          
        
      
        

          

            

            

                        book_name: event.book_name,
          
        
      
        

          

            

            

                        leader: {
          
        
      
        

          

            

            

                          id: event.leader.id,
          
        
      
        

          

            

            

                          nickname: event.leader.nickname
          
        
      
        

          

            

            

                        },
          
        
      
        

          

            

            

                        created_at: event.created_at,
          
        
      
        

          

            

            

                        enrollment_fee: event.enrollment_fee,
          
        
      
        

          

            

            

                        max_participants: event.max_participants
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    count: events.count
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # POST /api/admin/init_root
          
        
      
        

          

            

            

                def init_root_user
          
        
      
        

          

            

            

                  # 这个接口用于系统初始化时创建root用户
          
        
      
        

          

            

            

                  # 应该在系统部署后立即调用，然后禁用
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if User.exists?(role: :root)
          
        
      
        

          

            

            

                    return render json: { error: "Root用户已存在" }, status: :unprocessable_entity
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 这里应该有更严格的验证，比如特定的token或者IP限制
          
        
      
        

          

            

            

                  # 为了演示，这里简化处理
          
        
      
        

          

            

            

                  root_info = params.require(:root).permit(:wx_openid, :nickname, :avatar_url)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  user = User.new(root_info)
          
        
      
        

          

            

            

                  user.role = :root
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if user.save
          
        
      
        

          

            

            

                    render json: {
          
        
      
        

          

            

            

                      message: "Root用户创建成功",
          
        
      
        

          

            

            

                      user: {
          
        
      
        

          

            

            

                        id: user.id,
          
        
      
        

          

            

            

                        nickname: user.nickname,
          
        
      
        

          

            

            

                        role: user.role_display_name
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    render json: { errors: user.errors.full_messages }, status: :unprocessable_entity
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                private
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                def current_user_permissions
          
        
      
        

          

            

            

                  [
          
        
      
        

          

            

            

                    "approve_events",
          
        
      
        

          

            

            

                    "view_admin_panel"
          
        
      
        

          

            

            

                  ].select { |perm| current_user.has_permission?(perm.to_sym) }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                def admin_available_actions
          
        
      
        

          

            

            

                  actions = []
          
        
      
        

          

            

            

                  actions << { action: "approve_events", description: "审批活动" } if current_user.can_approve_events?
          
        
      
        

          

            

            

                  actions << { action: "manage_users", description: "管理用户" } if current_user.can_manage_users?
          
        
      
        

          

            

            

                  actions << { action: "view_admin_panel", description: "查看管理面板" } if current_user.can_view_admin_panel?
          
        
      
        

          

            

            

                  actions << { action: "manage_system", description: "管理系统" } if current_user.can_manage_system?
          
        
      
        

          

            

            

                  actions
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                def user_permissions_for(user)
          
        
      
        

          

            

            

                  permissions = []
          
        
      
        

          

            

            

                  permissions << "approve_events" if user.can_approve_events?
          
        
      
        

          

            

            

                  permissions << "manage_users" if user.can_manage_users?
          
        
      
        

          

            

            

                  permissions << "view_admin_panel" if user.can_view_admin_panel?
          
        
      
        

          

            

            

                  permissions << "manage_system" if user.can_manage_system?
          
        
      
        

          

            

            

                  permissions
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end
          
        
      
        

          

            

            

            end
          
        
      
    
  

    

      
        

          

            

            

            # frozen_string_literal: true
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            module Api
          
        
      
        

          

            

            

              class ApplicationController < ActionController::API
          
        
      
        

          

            

            

                # 简单的健康检查
          
        
      
        

          

            

            

                def health
          
        
      
        

          

            

            

                  render json: {
          
        
      
        

          

            

            

                    status: "ok",
          
        
      
        

          

            

            

                    timestamp: Time.current.iso8601,
          
        
      
        

          

            

            

                    environment: Rails.env,
          
        
      
        

          

            

            

                    version: "1.0.0"
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                private
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 从 JWT token 中获取当前用户
          
        
      
        

          

            

            

                def current_user
          
        
      
        

          

            

            

                  return unless auth_header_present?
          
        
      
        

          

            

            

                  return unless auth_token_valid?
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  user_id = decoded_jwt_token['user_id']
          
        
      
        

          

            

            

                  @current_user ||= User.find_by(id: user_id)
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 检查是否需要用户认证
          
        
      
        

          

            

            

                def authenticate_user!
          
        
      
        

          

            

            

                  return if current_user
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 提供更详细的错误信息用于调试
          
        
      
        

          

            

            

                  error_info = determine_auth_error
          
        
      
        

          

            

            

                  Rails.logger.warn "认证失败: #{error_info[:reason]} - #{error_info[:details]}"
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  render json: {
          
        
      
        

          

            

            

                    error: error_info[:message],
          
        
      
        

          

            

            

                    error_code: error_info[:code],
          
        
      
        

          

            

            

                    details: Rails.env.development? ? error_info[:details] : nil
          
        
      
        

          

            

            

                  }, status: :unauthorized
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                private
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                def auth_header_present?
          
        
      
        

          

            

            

                  request.headers['Authorization'].present?
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                def auth_token_valid?
          
        
      
        

          

            

            

                  auth_header = request.headers['Authorization']
          
        
      
        

          

            

            

                  token = auth_header.split(' ').last if auth_header
          
        
      
        

          

            

            

                  return false unless token
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  decoded_token = User.decode_jwt_token(token)
          
        
      
        

          

            

            

                  return false unless decoded_token
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 检查 token 是否过期
          
        
      
        

          

            

            

                  Time.current < Time.at(decoded_token['exp'])
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                def decoded_jwt_token
          
        
      
        

          

            

            

                  auth_header = request.headers['Authorization']
          
        
      
        

          

            

            

                  token = auth_header.split(' ').last if auth_header
          
        
      
        

          

            

            

                  @decoded_jwt_token ||= User.decode_jwt_token(token) if token
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 分析认证失败的具体原因
          
        
      
        

          

            

            

                def determine_auth_error
          
        
      
        

          

            

            

                  auth_header = request.headers['Authorization']
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 1. 检查是否有Authorization头
          
        
      
        

          

            

            

                  unless auth_header.present?
          
        
      
        

          

            

            

                    return {
          
        
      
        

          

            

            

                      code: 'MISSING_AUTH_HEADER',
          
        
      
        

          

            

            

                      message: '缺少认证信息',
          
        
      
        

          

            

            

                      reason: 'no_auth_header',
          
        
      
        

          

            

            

                      details: '请求头中缺少Authorization字段'
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 2. 检查Authorization格式
          
        
      
        

          

            

            

                  unless auth_header.start_with?('Bearer ')
          
        
      
        

          

            

            

                    return {
          
        
      
        

          

            

            

                      code: 'INVALID_AUTH_FORMAT',
          
        
      
        

          

            

            

                      message: '认证格式错误',
          
        
      
        

          

            

            

                      reason: 'invalid_auth_format',
          
        
      
        

          

            

            

                      details: "Authorization头格式应为'Bearer <token>'，当前为: #{auth_header[0..50]}..."
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 3. 提取token
          
        
      
        

          

            

            

                  token = auth_header.split(' ').last
          
        
      
        

          

            

            

                  unless token.present?
          
        
      
        

          

            

            

                    return {
          
        
      
        

          

            

            

                      code: 'MISSING_TOKEN',
          
        
      
        

          

            

            

                      message: '缺少认证令牌',
          
        
      
        

          

            

            

                      reason: 'missing_token',
          
        
      
        

          

            

            

                      details: 'Authorization头中缺少token部分'
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 4. 检查token格式
          
        
      
        

          

            

            

                  unless token.include?('.')
          
        
      
        

          

            

            

                    return {
          
        
      
        

          

            

            

                      code: 'INVALID_TOKEN_FORMAT',
          
        
      
        

          

            

            

                      message: '令牌格式错误',
          
        
      
        

          

            

            

                      reason: 'invalid_token_format',
          
        
      
        

          

            

            

                      details: 'JWT token应包含三个部分，用点分隔'
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 5. 尝试解码token
          
        
      
        

          

            

            

                  begin
          
        
      
        

          

            

            

                    decoded = User.decode_jwt_token(token)
          
        
      
        

          

            

            

                    unless decoded
          
        
      
        

          

            

            

                      return {
          
        
      
        

          

            

            

                        code: 'INVALID_TOKEN',
          
        
      
        

          

            

            

                        message: '令牌无效',
          
        
      
        

          

            

            

                        reason: 'decode_failed',
          
        
      
        

          

            

            

                        details: 'JWT token解码失败，可能被篡改或格式错误'
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                    # 6. 检查token是否过期
          
        
      
        

          

            

            

                    exp_time = decoded['exp']
          
        
      
        

          

            

            

                    if exp_time
          
        
      
        

          

            

            

                      current_time = Time.current.to_i
          
        
      
        

          

            

            

                      if current_time >= exp_time
          
        
      
        

          

            

            

                        expired_time = Time.at(exp_time)
          
        
      
        

          

            

            

                        return {
          
        
      
        

          

            

            

                          code: 'TOKEN_EXPIRED',
          
        
      
        

          

            

            

                          message: '令牌已过期',
          
        
      
        

          

            

            

                          reason: 'token_expired',
          
        
      
        

          

            

            

                          details: "Token已于#{expired_time.strftime('%Y-%m-%d %H:%M:%S')}过期"
          
        
      
        

          

            

            

                        }
          
        
      
        

          

            

            

                      end
          
        
      
        

          

            

            

                    end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                    # 7. 检查用户是否存在
          
        
      
        

          

            

            

                    user_id = decoded['user_id']
          
        
      
        

          

            

            

                    unless user_id
          
        
      
        

          

            

            

                      return {
          
        
      
        

          

            

            

                        code: 'INVALID_TOKEN_PAYLOAD',
          
        
      
        

          

            

            

                        message: '令牌内容无效',
          
        
      
        

          

            

            

                        reason: 'missing_user_id',
          
        
      
        

          

            

            

                        details: 'Token中缺少user_id字段'
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                    user = User.find_by(id: user_id)
          
        
      
        

          

            

            

                    unless user
          
        
      
        

          

            

            

                      return {
          
        
      
        

          

            

            

                        code: 'USER_NOT_FOUND',
          
        
      
        

          

            

            

                        message: '用户不存在',
          
        
      
        

          

            

            

                        reason: 'user_not_found',
          
        
      
        

          

            

            

                        details: "Token中用户ID(#{user_id})对应的用户不存在"
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                    # 8. 检查用户状态（如果需要）
          
        
      
        

          

            

            

                    # 这里可以添加用户状态检查逻辑
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  rescue => e
          
        
      
        

          

            

            

                    return {
          
        
      
        

          

            

            

                      code: 'TOKEN_PROCESSING_ERROR',
          
        
      
        

          

            

            

                      message: '令牌处理错误',
          
        
      
        

          

            

            

                      reason: 'processing_error',
          
        
      
        

          

            

            

                      details: "处理token时发生错误: #{e.message}"
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 未知错误
          
        
      
        

          

            

            

                  {
          
        
      
        

          

            

            

                    code: 'UNKNOWN_AUTH_ERROR',
          
        
      
        

          

            

            

                    message: '认证失败',
          
        
      
        

          

            

            

                    reason: 'unknown',
          
        
      
        

          

            

            

                    details: '认证过程中发生未知错误'
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end
          
        
      
    
  

    

      
        

          

            

            

            module Api
          
        
      
        

          

            

            

              class AuthController < Api::ApplicationController
          
        
      
        

          

            

            

                before_action :authenticate_user!, only: [:me, :update_profile]
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 引入Service
          
        
      
        

          

            

            

                def authentication_service
          
        
      
        

          

            

            

                  AuthenticationService
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 模拟登录（测试用）
          
        
      
        

          

            

            

                def mock_login
          
        
      
        

          

            

            

                  # 使用AuthenticationService处理模拟登录
          
        
      
        

          

            

            

                  service_result = authentication_service.mock_login!(params.to_unsafe_h)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if service_result.success?
          
        
      
        

          

            

            

                    render json: service_result.result
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    render json: { error: service_result.first_error }, status: :unprocessable_entity
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 微信登录（新版，支持用户信息传递）
          
        
      
        

          

            

            

                def wechat_login
          
        
      
        

          

            

            

                  # 使用AuthenticationService处理微信登录，支持传递用户信息
          
        
      
        

          

            

            

                  service_result = authentication_service.wechat_login!(params.to_unsafe_h)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if service_result.success?
          
        
      
        

          

            

            

                    render json: service_result.result
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    error_message = service_result.first_error
          
        
      
        

          

            

            

                    status_code = error_message.include?("code") ? :bad_request : :unauthorized
          
        
      
        

          

            

            

                    render json: { error: error_message }, status: status_code
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 微信登录（生产用）
          
        
      
        

          

            

            

                def login
          
        
      
        

          

            

            

                  # 使用AuthenticationService处理微信登录
          
        
      
        

          

            

            

                  service_result = authentication_service.wechat_login!(params.to_unsafe_h)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if service_result.success?
          
        
      
        

          

            

            

                    render json: service_result.result
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    error_message = service_result.first_error
          
        
      
        

          

            

            

                    status_code = error_message.include?("code") ? :bad_request : :unauthorized
          
        
      
        

          

            

            

                    render json: { error: error_message }, status: status_code
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 获取当前用户信息
          
        
      
        

          

            

            

                def me
          
        
      
        

          

            

            

                  render json: {
          
        
      
        

          

            

            

                    user: current_user.as_json_for_api
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 刷新访问令牌
          
        
      
        

          

            

            

                def refresh_token
          
        
      
        

          

            

            

                  refresh_token_param = params[:refresh_token]
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  unless refresh_token_param.present?
          
        
      
        

          

            

            

                    return render json: {
          
        
      
        

          

            

            

                      error: '缺少refresh_token参数',
          
        
      
        

          

            

            

                      error_code: 'MISSING_REFRESH_TOKEN'
          
        
      
        

          

            

            

                    }, status: :bad_request
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  result = User.refresh_access_token(refresh_token_param)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if result
          
        
      
        

          

            

            

                    render json: {
          
        
      
        

          

            

            

                      message: 'Token刷新成功',
          
        
      
        

          

            

            

                      access_token: result[:access_token],
          
        
      
        

          

            

            

                      refresh_token: result[:refresh_token],
          
        
      
        

          

            

            

                      user: result[:user]
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    render json: {
          
        
      
        

          

            

            

                      error: 'refresh_token无效或已过期',
          
        
      
        

          

            

            

                      error_code: 'INVALID_REFRESH_TOKEN'
          
        
      
        

          

            

            

                    }, status: :unauthorized
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 更新用户资料
          
        
      
        

          

            

            

                def update_profile
          
        
      
        

          

            

            

                  if current_user.update(profile_params)
          
        
      
        

          

            

            

                    render json: {
          
        
      
        

          

            

            

                      message: "更新成功",
          
        
      
        

          

            

            

                      user: {
          
        
      
        

          

            

            

                        id: current_user.id,
          
        
      
        

          

            

            

                        nickname: current_user.nickname,
          
        
      
        

          

            

            

                        avatar_url: current_user.avatar_url,
          
        
      
        

          

            

            

                        phone: current_user.phone
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    render json: { errors: current_user.errors.full_messages }, status: :unprocessable_entity
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # fetch_wechat_openid方法已移至AuthenticationService
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                def profile_params
          
        
      
        

          

            

            

                  params.require(:user).permit(:nickname, :avatar_url, :phone)
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end
          
        
      
    
  

    

      
        

          

            

            

            module Api
          
        
      
        

          

            

            

              class CheckInCommentsController < Api::ApplicationController
          
        
      
        

          

            

            

                include Commentable
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                before_action :set_check_in, only: [:index, :create]
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                private
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                def fetch_comments
          
        
      
        

          

            

            

                  @check_in.comments
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                def build_comment(params)
          
        
      
        

          

            

            

                  comment = @check_in.comments.new(params)
          
        
      
        

          

            

            

                  # 打卡评论不需要post_id
          
        
      
        

          

            

            

                  comment.post_id = nil
          
        
      
        

          

            

            

                  comment
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                def format_single_comment(comment, can_edit = false)
          
        
      
        

          

            

            

                  # 为打卡评论使用专门的JSON格式，保持兼容性
          
        
      
        

          

            

            

                  {
          
        
      
        

          

            

            

                    id: comment.id,
          
        
      
        

          

            

            

                    content: comment.content,
          
        
      
        

          

            

            

                    created_at: comment.created_at,
          
        
      
        

          

            

            

                    updated_at: comment.updated_at,
          
        
      
        

          

            

            

                    author_info: {
          
        
      
        

          

            

            

                      id: comment.user.id,
          
        
      
        

          

            

            

                      nickname: comment.user.nickname,
          
        
      
        

          

            

            

                      avatar_url: comment.user.avatar_url
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    can_edit_current_user: can_edit || can_edit_comment?(comment, current_user)
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                def set_check_in
          
        
      
        

          

            

            

                  @check_in = CheckIn.find(params[:check_in_id])
          
        
      
        

          

            

            

                rescue ActiveRecord::RecordNotFound
          
        
      
        

          

            

            

                  render_not_found('打卡不存在')
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end
          
        
      
    
  

    

      
        

          

            

            

            class Api::CheckInsController < ApplicationController
          
        
      
        

          

            

            

              include Authenticable
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # POST /api/reading_schedules/:reading_schedule_id/check_ins
          
        
      
        

          

            

            

              def create
          
        
      
        

          

            

            

                reading_schedule = ReadingSchedule.find(params[:reading_schedule_id])
          
        
      
        

          

            

            

                enrollment = current_user.enrollments.find_by(reading_event: reading_schedule.reading_event)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                unless enrollment
          
        
      
        

          

            

            

                  return render json: { error: "未报名该活动" }, status: :unprocessable_entity
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                check_in = CheckIn.new(check_in_params)
          
        
      
        

          

            

            

                check_in.user = current_user
          
        
      
        

          

            

            

                check_in.reading_schedule = reading_schedule
          
        
      
        

          

            

            

                check_in.enrollment = enrollment
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                if check_in.save
          
        
      
        

          

            

            

                  render json: check_in, status: :created
          
        
      
        

          

            

            

                else
          
        
      
        

          

            

            

                  render json: { error: check_in.errors.full_messages }, status: :unprocessable_entity
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # GET /api/reading_schedules/:reading_schedule_id/check_ins
          
        
      
        

          

            

            

              def index
          
        
      
        

          

            

            

                reading_schedule = ReadingSchedule.find(params[:reading_schedule_id])
          
        
      
        

          

            

            

                check_ins = reading_schedule.check_ins.includes(:user, :flower)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                render json: check_ins.map { |ci|
          
        
      
        

          

            

            

                  {
          
        
      
        

          

            

            

                    id: ci.id,
          
        
      
        

          

            

            

                    user: {
          
        
      
        

          

            

            

                      id: ci.user.id,
          
        
      
        

          

            

            

                      nickname: ci.user.nickname,
          
        
      
        

          

            

            

                      avatar_url: ci.user.avatar_url
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    content: ci.content,
          
        
      
        

          

            

            

                    word_count: ci.word_count,
          
        
      
        

          

            

            

                    status: ci.status,
          
        
      
        

          

            

            

                    submitted_at: ci.submitted_at,
          
        
      
        

          

            

            

                    has_flower: ci.has_flower?,
          
        
      
        

          

            

            

                    flower: ci.flower ? {
          
        
      
        

          

            

            

                      giver: {
          
        
      
        

          

            

            

                        id: ci.flower.giver.id,
          
        
      
        

          

            

            

                        nickname: ci.flower.giver.nickname
          
        
      
        

          

            

            

                      },
          
        
      
        

          

            

            

                      comment: ci.flower.comment
          
        
      
        

          

            

            

                    } : nil
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # GET /api/check_ins/:id
          
        
      
        

          

            

            

              def show
          
        
      
        

          

            

            

                check_in = CheckIn.includes(:user, :reading_schedule, :flower).find(params[:id])
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                render json: {
          
        
      
        

          

            

            

                  id: check_in.id,
          
        
      
        

          

            

            

                  user: {
          
        
      
        

          

            

            

                    id: check_in.user.id,
          
        
      
        

          

            

            

                    nickname: check_in.user.nickname,
          
        
      
        

          

            

            

                    avatar_url: check_in.user.avatar_url
          
        
      
        

          

            

            

                  },
          
        
      
        

          

            

            

                  reading_schedule: {
          
        
      
        

          

            

            

                    id: check_in.reading_schedule.id,
          
        
      
        

          

            

            

                    day_number: check_in.reading_schedule.day_number,
          
        
      
        

          

            

            

                    date: check_in.reading_schedule.date,
          
        
      
        

          

            

            

                    reading_progress: check_in.reading_schedule.reading_progress
          
        
      
        

          

            

            

                  },
          
        
      
        

          

            

            

                  content: check_in.content,
          
        
      
        

          

            

            

                  word_count: check_in.word_count,
          
        
      
        

          

            

            

                  status: check_in.status,
          
        
      
        

          

            

            

                  submitted_at: check_in.submitted_at,
          
        
      
        

          

            

            

                  updated_at: check_in.updated_at,
          
        
      
        

          

            

            

                  has_flower: check_in.has_flower?,
          
        
      
        

          

            

            

                  flower: check_in.flower ? {
          
        
      
        

          

            

            

                    giver: {
          
        
      
        

          

            

            

                      id: check_in.flower.giver.id,
          
        
      
        

          

            

            

                      nickname: check_in.flower.giver.nickname
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    comment: check_in.flower.comment,
          
        
      
        

          

            

            

                    created_at: check_in.flower.created_at
          
        
      
        

          

            

            

                  } : nil
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # PUT /api/check_ins/:id
          
        
      
        

          

            

            

              def update
          
        
      
        

          

            

            

                check_in = CheckIn.find(params[:id])
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 只能修改自己的打卡
          
        
      
        

          

            

            

                unless check_in.user_id == current_user.id
          
        
      
        

          

            

            

                  return render json: { error: "只能修改自己的打卡" }, status: :forbidden
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 如果已经获得小红花，不允许修改
          
        
      
        

          

            

            

                if check_in.has_flower?
          
        
      
        

          

            

            

                  return render json: { error: "已获得小红花的打卡不允许修改" }, status: :unprocessable_entity
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                if check_in.update(check_in_params)
          
        
      
        

          

            

            

                  render json: {
          
        
      
        

          

            

            

                    id: check_in.id,
          
        
      
        

          

            

            

                    content: check_in.content,
          
        
      
        

          

            

            

                    word_count: check_in.word_count,
          
        
      
        

          

            

            

                    status: check_in.status,
          
        
      
        

          

            

            

                    updated_at: check_in.updated_at
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                else
          
        
      
        

          

            

            

                  render json: { errors: check_in.errors.full_messages }, status: :unprocessable_entity
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              private
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              def check_in_params
          
        
      
        

          

            

            

                params.require(:check_in).permit(:content, :status)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end
          
        
      
    
  

    

      
        

          

            

            

            module Api
          
        
      
        

          

            

            

              class CommentsController < Api::ApplicationController
          
        
      
        

          

            

            

                include Commentable
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                before_action :set_post, only: [:index, :create]
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                private
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                def fetch_comments
          
        
      
        

          

            

            

                  @post.comments
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                def build_comment(params)
          
        
      
        

          

            

            

                  comment = @post.comments.new(params)
          
        
      
        

          

            

            

                  # 设置 commentable 关联
          
        
      
        

          

            

            

                  comment.commentable = @post
          
        
      
        

          

            

            

                  comment
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                def set_post
          
        
      
        

          

            

            

                  @post = Post.find(params[:post_id])
          
        
      
        

          

            

            

                rescue ActiveRecord::RecordNotFound
          
        
      
        

          

            

            

                  render_not_found('帖子不存在')
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end
          
        
      
    
  

    

      
        

          

            

            

            class Api::DailyLeadingsController < ApplicationController
          
        
      
        

          

            

            

              include Authenticable
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              skip_before_action :authenticate_user!, only: [:show]
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # POST /api/reading_schedules/:reading_schedule_id/daily_leading
          
        
      
        

          

            

            

              def create
          
        
      
        

          

            

            

                reading_schedule = ReadingSchedule.find(params[:reading_schedule_id])
          
        
      
        

          

            

            

                event = reading_schedule.reading_event
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 检查活动是否进行中
          
        
      
        

          

            

            

                unless event.in_progress?
          
        
      
        

          

            

            

                  return render json: { error: "活动未开始或已结束" }, status: :unprocessable_entity
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 检查是否有权限发布领读内容（前一天权限 + 小组长补位）
          
        
      
        

          

            

            

                unless event.can_publish_leading_content?(current_user, reading_schedule)
          
        
      
        

          

            

            

                  return render json: {
          
        
      
        

          

            

            

                    error: "只有领读人或小组长可以发布领读内容",
          
        
      
        

          

            

            

                    details: {
          
        
      
        

          

            

            

                      leader_permission: "领读人可提前一天或当天发布",
          
        
      
        

          

            

            

                      group_leader_permission: "小组长全程具备发布权限（补位机制）",
          
        
      
        

          

            

            

                      current_user_role: event.current_leader?(current_user) ? "小组长" : "普通用户",
          
        
      
        

          

            

            

                      is_schedule_leader: reading_schedule.daily_leader_id == current_user.id
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  }, status: :forbidden
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                daily_leading = reading_schedule.build_daily_leading(daily_leading_params)
          
        
      
        

          

            

            

                daily_leading.leader = current_user
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                if daily_leading.save
          
        
      
        

          

            

            

                  render json: {
          
        
      
        

          

            

            

                    id: daily_leading.id,
          
        
      
        

          

            

            

                    leader: {
          
        
      
        

          

            

            

                      id: daily_leading.leader.id,
          
        
      
        

          

            

            

                      nickname: daily_leading.leader.nickname,
          
        
      
        

          

            

            

                      avatar_url: daily_leading.leader.avatar_url
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    reading_suggestion: daily_leading.reading_suggestion,
          
        
      
        

          

            

            

                    questions: daily_leading.questions,
          
        
      
        

          

            

            

                    schedule_date: reading_schedule.date,
          
        
      
        

          

            

            

                    publish_window: "可提前一天或当天发布",
          
        
      
        

          

            

            

                    created_at: daily_leading.created_at
          
        
      
        

          

            

            

                  }, status: :created
          
        
      
        

          

            

            

                else
          
        
      
        

          

            

            

                  render json: { error: daily_leading.errors.full_messages }, status: :unprocessable_entity
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # GET /api/reading_schedules/:reading_schedule_id/daily_leading
          
        
      
        

          

            

            

              def show
          
        
      
        

          

            

            

                reading_schedule = ReadingSchedule.find(params[:reading_schedule_id])
          
        
      
        

          

            

            

                daily_leading = reading_schedule.daily_leading
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                if daily_leading
          
        
      
        

          

            

            

                  render json: {
          
        
      
        

          

            

            

                    id: daily_leading.id,
          
        
      
        

          

            

            

                    leader: {
          
        
      
        

          

            

            

                      id: daily_leading.leader.id,
          
        
      
        

          

            

            

                      nickname: daily_leading.leader.nickname,
          
        
      
        

          

            

            

                      avatar_url: daily_leading.leader.avatar_url
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    reading_suggestion: daily_leading.reading_suggestion,
          
        
      
        

          

            

            

                    questions: daily_leading.questions,
          
        
      
        

          

            

            

                    created_at: daily_leading.created_at
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                else
          
        
      
        

          

            

            

                  render json: { error: "今日暂无领读内容" }, status: :not_found
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # PUT /api/reading_schedules/:reading_schedule_id/daily_leading
          
        
      
        

          

            

            

              def update
          
        
      
        

          

            

            

                reading_schedule = ReadingSchedule.find(params[:reading_schedule_id])
          
        
      
        

          

            

            

                daily_leading = reading_schedule.daily_leading
          
        
      
        

          

            

            

                event = reading_schedule.reading_event
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                unless daily_leading
          
        
      
        

          

            

            

                  return render json: { error: "领读内容不存在" }, status: :not_found
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 检查活动是否进行中
          
        
      
        

          

            

            

                unless event.in_progress?
          
        
      
        

          

            

            

                  return render json: { error: "活动未开始或已结束" }, status: :unprocessable_entity
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 检查权限：原作者或当前有效的小组长
          
        
      
        

          

            

            

                is_original_author = daily_leading.leader_id == current_user.id
          
        
      
        

          

            

            

                is_current_leader = event.current_leader?(current_user)
          
        
      
        

          

            

            

                is_today_leader = event.current_daily_leader?(current_user, reading_schedule)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                unless is_original_author || is_current_leader || is_today_leader
          
        
      
        

          

            

            

                  return render json: { error: "无权限修改该内容" }, status: :forbidden
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 如果当天已经有打卡，不建议修改领读内容
          
        
      
        

          

            

            

                if reading_schedule.check_ins.any?
          
        
      
        

          

            

            

                  return render json: { error: "已有用户打卡，不建议修改领读内容" }, status: :unprocessable_entity
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                if daily_leading.update(daily_leading_params)
          
        
      
        

          

            

            

                  render json: {
          
        
      
        

          

            

            

                    id: daily_leading.id,
          
        
      
        

          

            

            

                    leader: {
          
        
      
        

          

            

            

                      id: daily_leading.leader.id,
          
        
      
        

          

            

            

                      nickname: daily_leading.leader.nickname,
          
        
      
        

          

            

            

                      avatar_url: daily_leading.leader.avatar_url
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    reading_suggestion: daily_leading.reading_suggestion,
          
        
      
        

          

            

            

                    questions: daily_leading.questions,
          
        
      
        

          

            

            

                    updated_at: daily_leading.updated_at
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                else
          
        
      
        

          

            

            

                  render json: { error: daily_leading.errors.full_messages }, status: :unprocessable_entity
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              private
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              def daily_leading_params
          
        
      
        

          

            

            

                params.require(:daily_leading).permit(:reading_suggestion, :questions)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end
          
        
      
    
  

    

      
        

          

            

            

            module Api
          
        
      
        

          

            

            

              class EventsController < Api::ApplicationController
          
        
      
        

          

            

            

                skip_before_action :authenticate_user!, only: [:index, :show], raise: false
          
        
      
        

          

            

            

                include AdminAuthorizable
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # GET /api/events
          
        
      
        

          

            

            

                def index
          
        
      
        

          

            

            

                  @events = ReadingEvent.includes(:leader).order(created_at: :desc)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 筛选条件
          
        
      
        

          

            

            

                  @events = @events.where(status: params[:status]) if params[:status].present?
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  render json: @events.map { |event| event_json(event) }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # GET /api/events/:id
          
        
      
        

          

            

            

                def show
          
        
      
        

          

            

            

                  @event = ReadingEvent.includes(:leader, :participants).find(params[:id])
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  render json: event_detail_json(@event)
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # POST /api/events
          
        
      
        

          

            

            

                def create
          
        
      
        

          

            

            

                  @event = current_user.created_events.new(event_params)
          
        
      
        

          

            

            

                  @event.leader = current_user
          
        
      
        

          

            

            

                  @event.approval_status = :pending  # 新活动默认待审批
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if @event.save
          
        
      
        

          

            

            

                    # 自动生成阅读计划
          
        
      
        

          

            

            

                    generate_reading_schedules(@event)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                    render json: event_json(@event), status: :created
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    render json: { errors: @event.errors.full_messages }, status: :unprocessable_entity
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # PUT /api/events/:id
          
        
      
        

          

            

            

                def update
          
        
      
        

          

            

            

                  @event = current_user.created_events.find(params[:id])
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if @event.update(event_params)
          
        
      
        

          

            

            

                    render json: event_json(@event)
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    render json: { errors: @event.errors.full_messages }, status: :unprocessable_entity
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # DELETE /api/events/:id
          
        
      
        

          

            

            

                def destroy
          
        
      
        

          

            

            

                  @event = current_user.created_events.find(params[:id])
          
        
      
        

          

            

            

                  @event.destroy
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  head :no_content
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # POST /api/events/:id/enroll
          
        
      
        

          

            

            

                def enroll
          
        
      
        

          

            

            

                  @event = ReadingEvent.find(params[:id])
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 使用EventEnrollmentService处理报名
          
        
      
        

          

            

            

                  service_result = EventEnrollmentService.enroll_user!(@event, current_user)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if service_result.success?
          
        
      
        

          

            

            

                    render json: service_result.result, status: :created
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    render json: { error: service_result.first_error }, status: :unprocessable_entity
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # POST /api/events/:id/approve
          
        
      
        

          

            

            

                def approve
          
        
      
        

          

            

            

                  @event = ReadingEvent.find(params[:id])
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 检查是否有审批权限
          
        
      
        

          

            

            

                  authorize_event_approval!
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 使用EventManagementService处理审批
          
        
      
        

          

            

            

                  service_result = EventManagementService.approve_event!(@event, current_user)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if service_result.success?
          
        
      
        

          

            

            

                    render json: service_result.result
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    render json: { error: service_result.first_error }, status: :unprocessable_entity
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # POST /api/events/:id/reject
          
        
      
        

          

            

            

                def reject
          
        
      
        

          

            

            

                  @event = ReadingEvent.find(params[:id])
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 检查是否有审批权限
          
        
      
        

          

            

            

                  authorize_event_approval!
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 使用EventManagementService处理拒绝
          
        
      
        

          

            

            

                  service_result = EventManagementService.reject_event!(@event, current_user)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if service_result.success?
          
        
      
        

          

            

            

                    render json: service_result.result
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    render json: { error: service_result.first_error }, status: :unprocessable_entity
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # POST /api/events/:id/claim_leadership
          
        
      
        

          

            

            

                def claim_leadership
          
        
      
        

          

            

            

                  @event = ReadingEvent.find(params[:id])
          
        
      
        

          

            

            

                  schedule = @event.reading_schedules.find(params[:schedule_id])
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 使用LeaderAssignmentService处理领读报名
          
        
      
        

          

            

            

                  service_result = LeaderAssignmentService.claim_leadership!(@event, current_user, schedule)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if service_result.success?
          
        
      
        

          

            

            

                    render json: service_result.result
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    render json: { error: service_result.first_error }, status: :unprocessable_entity
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # POST /api/events/:id/complete
          
        
      
        

          

            

            

                def complete
          
        
      
        

          

            

            

                  @event = ReadingEvent.find(params[:id])
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 使用EventManagementService处理活动完成
          
        
      
        

          

            

            

                  service_result = EventManagementService.complete_event!(@event, current_user)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if service_result.success?
          
        
      
        

          

            

            

                    render json: service_result.result
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    status_code = service_result.first_error.include?("只有") ? :forbidden : :unprocessable_entity
          
        
      
        

          

            

            

                    render json: { error: service_result.first_error }, status: status_code
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # GET /api/events/:id/backup_needed
          
        
      
        

          

            

            

                def backup_needed
          
        
      
        

          

            

            

                  @event = ReadingEvent.find(params[:id])
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 检查是否是当前有效的小组长
          
        
      
        

          

            

            

                  unless @event.current_leader?(current_user)
          
        
      
        

          

            

            

                    return render json: { error: "只有活动小组长可以查看补位信息" }, status: :forbidden
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  backup_schedules = @event.schedules_need_backup
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  render json: {
          
        
      
        

          

            

            

                    event_id: @event.id,
          
        
      
        

          

            

            

                    event_title: @event.title,
          
        
      
        

          

            

            

                    backup_needed: backup_schedules,
          
        
      
        

          

            

            

                    summary: {
          
        
      
        

          

            

            

                      total_needing_backup: backup_schedules.count,
          
        
      
        

          

            

            

                      missing_content_count: backup_schedules.count { |s| s[:missing_content] },
          
        
      
        

          

            

            

                      missing_flowers_count: backup_schedules.count { |s| s[:missing_flowers] },
          
        
      
        

          

            

            

                      urgent_count: backup_schedules.count { |s| s[:date] <= Date.today }
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    leader_permissions: {
          
        
      
        

          

            

            

                      can_publish_content: true,
          
        
      
        

          

            

            

                      can_give_flowers: true,
          
        
      
        

          

            

            

                      backup_mechanism: "小组长全程具备领读权限，可随时补位"
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                private
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                def event_params
          
        
      
        

          

            

            

                  params.require(:event).permit(
          
        
      
        

          

            

            

                    :title, :book_name, :book_cover_url, :description,
          
        
      
        

          

            

            

                    :start_date, :end_date, :max_participants, :enrollment_fee, :status,
          
        
      
        

          

            

            

                    :leader_assignment_type
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                def event_json(event)
          
        
      
        

          

            

            

                  {
          
        
      
        

          

            

            

                    id: event.id,
          
        
      
        

          

            

            

                    title: event.title,
          
        
      
        

          

            

            

                    book_name: event.book_name,
          
        
      
        

          

            

            

                    book_cover_url: event.book_cover_url,
          
        
      
        

          

            

            

                    description: event.description,
          
        
      
        

          

            

            

                    start_date: event.start_date,
          
        
      
        

          

            

            

                    end_date: event.end_date,
          
        
      
        

          

            

            

                    max_participants: event.max_participants,
          
        
      
        

          

            

            

                    enrollment_fee: event.enrollment_fee,
          
        
      
        

          

            

            

                    service_fee: event.service_fee,
          
        
      
        

          

            

            

                    deposit: event.deposit,
          
        
      
        

          

            

            

                    status: event.status,
          
        
      
        

          

            

            

                    approval_status: event.approval_status,
          
        
      
        

          

            

            

                    leader_assignment_type: event.leader_assignment_type,
          
        
      
        

          

            

            

                    days_count: event.days_count,
          
        
      
        

          

            

            

                    leader: {
          
        
      
        

          

            

            

                      id: event.leader.id,
          
        
      
        

          

            

            

                      nickname: event.leader.nickname,
          
        
      
        

          

            

            

                      avatar_url: event.leader.avatar_url
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    approved_by: event.approved_by ? {
          
        
      
        

          

            

            

                      id: event.approved_by.id,
          
        
      
        

          

            

            

                      nickname: event.approved_by.nickname
          
        
      
        

          

            

            

                    } : nil,
          
        
      
        

          

            

            

                    approved_at: event.approved_at,
          
        
      
        

          

            

            

                    created_at: event.created_at
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                def event_detail_json(event)
          
        
      
        

          

            

            

                  event_json(event).merge(
          
        
      
        

          

            

            

                    participants_count: event.participants.count,
          
        
      
        

          

            

            

                    participants: event.participants.map { |user|
          
        
      
        

          

            

            

                      {
          
        
      
        

          

            

            

                        id: user.id,
          
        
      
        

          

            

            

                        nickname: user.nickname,
          
        
      
        

          

            

            

                        avatar_url: user.avatar_url
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # enrollment_json方法已移至EventEnrollmentService
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                def generate_reading_schedules(event)
          
        
      
        

          

            

            

                  days_count = event.days_count
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  days_count.times do |i|
          
        
      
        

          

            

            

                    event.reading_schedules.create!(
          
        
      
        

          

            

            

                      day_number: i + 1,
          
        
      
        

          

            

            

                      date: event.start_date + i.days,
          
        
      
        

          

            

            

                      reading_progress: "第 #{i + 1} 天阅读计划（待领读人填写）"
          
        
      
        

          

            

            

                    )
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end
          
        
      
    
  

    

      
        

          

            

            

            class Api::FlowersController < ApplicationController
          
        
      
        

          

            

            

              include Authenticable
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # POST /api/check_ins/:check_in_id/flower
          
        
      
        

          

            

            

              def create
          
        
      
        

          

            

            

                check_in = CheckIn.find(params[:check_in_id])
          
        
      
        

          

            

            

                reading_schedule = check_in.reading_schedule
          
        
      
        

          

            

            

                event = reading_schedule.reading_event
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 不能给自己的打卡送花
          
        
      
        

          

            

            

                if check_in.user_id == current_user.id
          
        
      
        

          

            

            

                  return render json: { error: "不能给自己送小红花" }, status: :unprocessable_entity
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 检查是否有权限发放小红花（当天和后一天权限 + 小组长补位）
          
        
      
        

          

            

            

                unless event.can_give_flowers?(current_user, reading_schedule)
          
        
      
        

          

            

            

                  return render json: {
          
        
      
        

          

            

            

                    error: "只有领读人或小组长可以发放小红花",
          
        
      
        

          

            

            

                    details: {
          
        
      
        

          

            

            

                      leader_permission: "领读人可在当天或后一天发放",
          
        
      
        

          

            

            

                      group_leader_permission: "小组长全程具备发放权限（补位机制）",
          
        
      
        

          

            

            

                      current_user_role: event.current_leader?(current_user) ? "小组长" : "普通用户",
          
        
      
        

          

            

            

                      flower_window: "小红花发放窗口灵活，支持补位机制"
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  }, status: :forbidden
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                flower = Flower.new(flower_params)
          
        
      
        

          

            

            

                flower.check_in = check_in
          
        
      
        

          

            

            

                flower.giver = current_user
          
        
      
        

          

            

            

                flower.recipient = check_in.user
          
        
      
        

          

            

            

                flower.reading_schedule = reading_schedule
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                if flower.save
          
        
      
        

          

            

            

                  render json: {
          
        
      
        

          

            

            

                    id: flower.id,
          
        
      
        

          

            

            

                    check_in_id: flower.check_in_id,
          
        
      
        

          

            

            

                    giver: {
          
        
      
        

          

            

            

                      id: flower.giver.id,
          
        
      
        

          

            

            

                      nickname: flower.giver.nickname,
          
        
      
        

          

            

            

                      avatar_url: flower.giver.avatar_url
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    recipient: {
          
        
      
        

          

            

            

                      id: flower.recipient.id,
          
        
      
        

          

            

            

                      nickname: flower.recipient.nickname,
          
        
      
        

          

            

            

                      avatar_url: flower.recipient.avatar_url
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    comment: flower.comment,
          
        
      
        

          

            

            

                    flower_window: "领读人可在当天或后一天发放小红花",
          
        
      
        

          

            

            

                    created_at: flower.created_at
          
        
      
        

          

            

            

                  }, status: :created
          
        
      
        

          

            

            

                else
          
        
      
        

          

            

            

                  render json: { error: flower.errors.full_messages }, status: :unprocessable_entity
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # GET /api/reading_schedules/:reading_schedule_id/flowers
          
        
      
        

          

            

            

              def index
          
        
      
        

          

            

            

                reading_schedule = ReadingSchedule.find(params[:reading_schedule_id])
          
        
      
        

          

            

            

                flowers = reading_schedule.flowers.includes(:giver, :recipient, :check_in)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                render json: flowers.map { |flower|
          
        
      
        

          

            

            

                  {
          
        
      
        

          

            

            

                    id: flower.id,
          
        
      
        

          

            

            

                    giver: {
          
        
      
        

          

            

            

                      id: flower.giver.id,
          
        
      
        

          

            

            

                      nickname: flower.giver.nickname,
          
        
      
        

          

            

            

                      avatar_url: flower.giver.avatar_url
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    recipient: {
          
        
      
        

          

            

            

                      id: flower.recipient.id,
          
        
      
        

          

            

            

                      nickname: flower.recipient.nickname,
          
        
      
        

          

            

            

                      avatar_url: flower.recipient.avatar_url
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    check_in: {
          
        
      
        

          

            

            

                      id: flower.check_in.id,
          
        
      
        

          

            

            

                      content: flower.check_in.content.truncate(100)
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    comment: flower.comment,
          
        
      
        

          

            

            

                    created_at: flower.created_at
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # GET /api/users/:user_id/flowers
          
        
      
        

          

            

            

              def user_flowers
          
        
      
        

          

            

            

                user = User.find(params[:user_id])
          
        
      
        

          

            

            

                flowers = Flower.where(recipient: user).includes(:giver, :reading_schedule, :check_in)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                render json: {
          
        
      
        

          

            

            

                  total_count: flowers.count,
          
        
      
        

          

            

            

                  flowers: flowers.map { |flower|
          
        
      
        

          

            

            

                    {
          
        
      
        

          

            

            

                      id: flower.id,
          
        
      
        

          

            

            

                      giver: {
          
        
      
        

          

            

            

                        id: flower.giver.id,
          
        
      
        

          

            

            

                        nickname: flower.giver.nickname,
          
        
      
        

          

            

            

                        avatar_url: flower.giver.avatar_url
          
        
      
        

          

            

            

                      },
          
        
      
        

          

            

            

                      reading_schedule: {
          
        
      
        

          

            

            

                        id: flower.reading_schedule.id,
          
        
      
        

          

            

            

                        day_number: flower.reading_schedule.day_number,
          
        
      
        

          

            

            

                        date: flower.reading_schedule.date
          
        
      
        

          

            

            

                      },
          
        
      
        

          

            

            

                      check_in: {
          
        
      
        

          

            

            

                        id: flower.check_in.id,
          
        
      
        

          

            

            

                        content: flower.check_in.content.truncate(100)
          
        
      
        

          

            

            

                      },
          
        
      
        

          

            

            

                      comment: flower.comment,
          
        
      
        

          

            

            

                      created_at: flower.created_at
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              private
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              def flower_params
          
        
      
        

          

            

            

                params.require(:flower).permit(:comment)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end
          
        
      
    
  

    

      
        

          

            

            

            module Api
          
        
      
        

          

            

            

              class LikesController < Api::ApplicationController
          
        
      
        

          

            

            

                before_action :authenticate_user!
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # POST /api/posts/:post_id/like
          
        
      
        

          

            

            

                def create
          
        
      
        

          

            

            

                  target = find_target
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if target.nil?
          
        
      
        

          

            

            

                    return render json: { error: '目标不存在' }, status: :not_found
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if Like.like!(current_user, target)
          
        
      
        

          

            

            

                    render json: {
          
        
      
        

          

            

            

                      message: '点赞成功',
          
        
      
        

          

            

            

                      liked: true,
          
        
      
        

          

            

            

                      likes_count: target.likes_count
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    render json: { error: '已经点赞过了' }, status: :unprocessable_entity
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # DELETE /api/posts/:post_id/like
          
        
      
        

          

            

            

                def destroy
          
        
      
        

          

            

            

                  target = find_target
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if target.nil?
          
        
      
        

          

            

            

                    return render json: { error: '目标不存在' }, status: :not_found
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if Like.unlike!(current_user, target)
          
        
      
        

          

            

            

                    render json: {
          
        
      
        

          

            

            

                      message: '取消点赞成功',
          
        
      
        

          

            

            

                      liked: false,
          
        
      
        

          

            

            

                      likes_count: target.likes_count
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    render json: { error: '还未点赞' }, status: :unprocessable_entity
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                private
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                def find_target
          
        
      
        

          

            

            

                  case params[:post_id]
          
        
      
        

          

            

            

                  when nil
          
        
      
        

          

            

            

                    nil
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    Post.find(params[:post_id])
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                rescue ActiveRecord::RecordNotFound
          
        
      
        

          

            

            

                  nil
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end
          
        
      
    
  

    

      
        

          

            

            

            # frozen_string_literal: true
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            module Api
          
        
      
        

          

            

            

              # 优化版本的PostsController - 解决N+1查询问题
          
        
      
        

          

            

            

              class OptimizedPostsController < Api::ApplicationController
          
        
      
        

          

            

            

                before_action :authenticate_user!
          
        
      
        

          

            

            

                include AdminAuthorizable
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # GET /api/posts
          
        
      
        

          

            

            

                def index
          
        
      
        

          

            

            

                  # 基础查询，预加载所有必要的关联
          
        
      
        

          

            

            

                  @posts = base_posts_query
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 按分类筛选
          
        
      
        

          

            

            

                  if params[:category].present?
          
        
      
        

          

            

            

                    @posts = @posts.by_category(params[:category])
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 分页处理
          
        
      
        

          

            

            

                  @posts = paginate_posts(@posts)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 批量预加载权限信息
          
        
      
        

          

            

            

                  preload_permissions(@posts, current_user) if current_user
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 批量预加载点赞状态
          
        
      
        

          

            

            

                  preload_like_status(@posts, current_user) if current_user
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  render json: optimized_posts_json(@posts)
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # GET /api/posts/:id
          
        
      
        

          

            

            

                def show
          
        
      
        

          

            

            

                  @post = Post.find(params[:id])
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 检查权限：普通用户看不到隐藏帖子
          
        
      
        

          

            

            

                  unless current_user.any_admin?
          
        
      
        

          

            

            

                    if @post.hidden?
          
        
      
        

          

            

            

                      return render json: { error: "帖子已被隐藏" }, status: :not_found
          
        
      
        

          

            

            

                    end
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  render json: optimized_post_json(@post)
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                private
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 基础帖子查询
          
        
      
        

          

            

            

                def base_posts_query
          
        
      
        

          

            

            

                  # 如果是管理员，可以看到所有帖子
          
        
      
        

          

            

            

                  if current_user.any_admin?
          
        
      
        

          

            

            

                    Post.includes(:user)
          
        
      
        

          

            

            

                          .order(pinned: :desc, created_at: :desc)
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    Post.visible.includes(:user)
          
        
      
        

          

            

            

                          .order(pinned: :desc, created_at: :desc)
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 分页处理
          
        
      
        

          

            

            

                def paginate_posts(query)
          
        
      
        

          

            

            

                  page = params[:page].to_i > 0 ? params[:page].to_i : 1
          
        
      
        

          

            

            

                  per_page = params[:per_page].to_i > 0 ? [params[:per_page].to_i, 50].min : 20
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  @total_count = query.count
          
        
      
        

          

            

            

                  query.limit(per_page).offset((page - 1) * per_page)
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 批量预加载权限信息
          
        
      
        

          

            

            

                def preload_permissions(posts, user)
          
        
      
        

          

            

            

                  post_ids = posts.map(&:id)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 批量获取权限信息
          
        
      
        

          

            

            

                  permissions = PostPermissionService.batch_check_posts_permissions(
          
        
      
        

          

            

            

                    post_ids,
          
        
      
        

          

            

            

                    user.id,
          
        
      
        

          

            

            

                    [:edit, :delete, :pin, :hide, :comment]
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 将权限信息附加到每个post对象
          
        
      
        

          

            

            

                  posts.each do |post|
          
        
      
        

          

            

            

                    post_id = post.id
          
        
      
        

          

            

            

                    post.instance_variable_set(:@permissions, {
          
        
      
        

          

            

            

                      can_edit: permissions.dig(:edit, post_id) || false,
          
        
      
        

          

            

            

                      can_delete: permissions.dig(:delete, post_id) || false,
          
        
      
        

          

            

            

                      can_pin: permissions.dig(:pin, post_id) || false,
          
        
      
        

          

            

            

                      can_hide: permissions.dig(:hide, post_id) || false,
          
        
      
        

          

            

            

                      can_comment: permissions.dig(:comment, post_id) || false
          
        
      
        

          

            

            

                    })
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 批量预加载点赞状态
          
        
      
        

          

            

            

                def preload_like_status(posts, user)
          
        
      
        

          

            

            

                  post_ids = posts.map(&:id)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 一次性查询用户对所有帖子的点赞状态
          
        
      
        

          

            

            

                  liked_post_ids = Like.where(
          
        
      
        

          

            

            

                    user_id: user.id,
          
        
      
        

          

            

            

                    target_type: 'Post',
          
        
      
        

          

            

            

                    target_id: post_ids
          
        
      
        

          

            

            

                  ).pluck(:target_id)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 将点赞状态附加到每个post对象
          
        
      
        

          

            

            

                  posts.each do |post|
          
        
      
        

          

            

            

                    post.instance_variable_set(:@current_user_liked, liked_post_ids.include?(post.id))
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 优化的帖子JSON序列化
          
        
      
        

          

            

            

                def optimized_posts_json(posts)
          
        
      
        

          

            

            

                  {
          
        
      
        

          

            

            

                    posts: posts.map { |post| optimized_post_json(post, lite: true) },
          
        
      
        

          

            

            

                    pagination: {
          
        
      
        

          

            

            

                      current_page: params[:page].to_i > 0 ? params[:page].to_i : 1,
          
        
      
        

          

            

            

                      per_page: params[:per_page].to_i > 0 ? [params[:per_page].to_i, 50].min : 20,
          
        
      
        

          

            

            

                      total_count: @total_count,
          
        
      
        

          

            

            

                      total_pages: (@total_count.to_f / [params[:per_page].to_i, 50].min).ceil,
          
        
      
        

          

            

            

                      has_next: (params[:page].to_i > 0 ? params[:page].to_i : 1) * [params[:per_page].to_i, 50].min < @total_count,
          
        
      
        

          

            

            

                      has_prev: (params[:page].to_i > 0 ? params[:page].to_i : 1) > 1
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 优化的单个帖子JSON序列化
          
        
      
        

          

            

            

                def optimized_post_json(post, lite: false)
          
        
      
        

          

            

            

                  permissions = post.instance_variable_get(:@permissions) || {}
          
        
      
        

          

            

            

                  liked_status = post.instance_variable_get(:@current_user_liked)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  result = {
          
        
      
        

          

            

            

                    id: post.id,
          
        
      
        

          

            

            

                    title: post.title,
          
        
      
        

          

            

            

                    content: post.content,
          
        
      
        

          

            

            

                    category: post.category,
          
        
      
        

          

            

            

                    category_name: post.category_name,
          
        
      
        

          

            

            

                    pinned: post.pinned,
          
        
      
        

          

            

            

                    hidden: post.hidden,
          
        
      
        

          

            

            

                    created_at: post.created_at,
          
        
      
        

          

            

            

                    updated_at: post.updated_at,
          
        
      
        

          

            

            

                    time_ago: post.time_ago_in_words(post.created_at),
          
        
      
        

          

            

            

                    stats: {
          
        
      
        

          

            

            

                      likes_count: post.likes_count,
          
        
      
        

          

            

            

                      comments_count: post.comments_count
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    author: post.user.as_json_for_api
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 添加当前用户的交互状态（仅在需要时）
          
        
      
        

          

            

            

                  if current_user && !lite
          
        
      
        

          

            

            

                    result[:interactions] = {
          
        
      
        

          

            

            

                      liked: liked_status || post.liked_by?(current_user),
          
        
      
        

          

            

            

                      can_edit: permissions[:can_edit] || post.can_edit?(current_user),
          
        
      
        

          

            

            

                      can_delete: permissions[:can_delete] || post.can_delete?(current_user),
          
        
      
        

          

            

            

                      can_pin: permissions[:can_pin] || post.can_pin?(current_user),
          
        
      
        

          

            

            

                      can_hide: permissions[:can_hide] || post.can_hide?(current_user),
          
        
      
        

          

            

            

                      can_comment: permissions[:can_comment] || post.can_comment?(current_user)
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 包含关联数据（仅在详情页面）
          
        
      
        

          

            

            

                  if !lite && params[:include_comments] == 'true'
          
        
      
        

          

            

            

                    result[:recent_comments] = post.comments.limit(5).includes(:user).map(&:as_json_for_api)
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if !lite && params[:include_likes] == 'true'
          
        
      
        

          

            

            

                    result[:recent_likes] = post.likes.limit(10).includes(:user).map do |like|
          
        
      
        

          

            

            

                      {
          
        
      
        

          

            

            

                        id: like.id,
          
        
      
        

          

            

            

                        user: like.user.as_json_for_api,
          
        
      
        

          

            

            

                        created_at: like.created_at
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    end
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  result
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                def post_params
          
        
      
        

          

            

            

                  params.require(:post).permit(:title, :content, :category, :images, tags: [])
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end
          
        
      
    
  

    

      
        

          

            

            

            module Api
          
        
      
        

          

            

            

              class PostsController < Api::ApplicationController
          
        
      
        

          

            

            

                before_action :authenticate_user!
          
        
      
        

          

            

            

                include AdminAuthorizable
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # GET /api/posts
          
        
      
        

          

            

            

                def index
          
        
      
        

          

            

            

                  @posts = Post.visible.includes(:user).pinned_first
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 如果是管理员，可以看到所有帖子
          
        
      
        

          

            

            

                  if current_user.any_admin?
          
        
      
        

          

            

            

                    @posts = Post.includes(:user).pinned_first
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 按分类筛选
          
        
      
        

          

            

            

                  if params[:category].present?
          
        
      
        

          

            

            

                    @posts = @posts.by_category(params[:category])
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  render json: @posts.map { |post|
          
        
      
        

          

            

            

                    post.instance_variable_set(:@can_edit_current_user, post.can_edit?(current_user))
          
        
      
        

          

            

            

                    post.instance_variable_set(:@current_user, current_user)
          
        
      
        

          

            

            

                    post.as_json
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # GET /api/posts/:id
          
        
      
        

          

            

            

                def show
          
        
      
        

          

            

            

                  @post = Post.find(params[:id])
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 检查权限：普通用户看不到隐藏帖子
          
        
      
        

          

            

            

                  unless current_user.any_admin?
          
        
      
        

          

            

            

                    if @post.hidden?
          
        
      
        

          

            

            

                      return render json: { error: "帖子已被隐藏" }, status: :not_found
          
        
      
        

          

            

            

                    end
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  @post.instance_variable_set(:@can_edit_current_user, @post.can_edit?(current_user))
          
        
      
        

          

            

            

                  @post.instance_variable_set(:@current_user, current_user)
          
        
      
        

          

            

            

                  render json: @post.as_json
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # POST /api/posts
          
        
      
        

          

            

            

                def create
          
        
      
        

          

            

            

                  # 使用PostManagementService处理帖子创建
          
        
      
        

          

            

            

                  service_result = PostManagementService.create_post!(current_user, post_params)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if service_result.success?
          
        
      
        

          

            

            

                    render json: service_result.result, status: :created
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    render json: { errors: service_result.error_messages }, status: :unprocessable_entity
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # PUT /api/posts/:id
          
        
      
        

          

            

            

                def update
          
        
      
        

          

            

            

                  @post = Post.find(params[:id])
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 使用PostManagementService处理帖子更新
          
        
      
        

          

            

            

                  service_result = PostManagementService.update_post!(@post, current_user, post_params)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if service_result.success?
          
        
      
        

          

            

            

                    render json: service_result.result
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    error_message = service_result.first_error
          
        
      
        

          

            

            

                    status_code = error_message.include?("权限") ? :forbidden : :unprocessable_entity
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                    # 对于验证错误，使用errors格式；对于权限错误，使用error格式
          
        
      
        

          

            

            

                    if service_result.error_messages.any? && service_result.error_messages.first.include?("can't be blank")
          
        
      
        

          

            

            

                      render json: { errors: service_result.error_messages }, status: status_code
          
        
      
        

          

            

            

                    else
          
        
      
        

          

            

            

                      render json: { error: error_message }, status: status_code
          
        
      
        

          

            

            

                    end
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # DELETE /api/posts/:id
          
        
      
        

          

            

            

                def destroy
          
        
      
        

          

            

            

                  @post = Post.find(params[:id])
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 使用PostManagementService处理帖子删除
          
        
      
        

          

            

            

                  service_result = PostManagementService.delete_post!(@post, current_user)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if service_result.success?
          
        
      
        

          

            

            

                    head :no_content
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    error_message = service_result.first_error
          
        
      
        

          

            

            

                    status_code = error_message.include?("权限") ? :forbidden : :unprocessable_entity
          
        
      
        

          

            

            

                    render json: { error: error_message }, status: status_code
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # POST /api/posts/:id/pin  # 置顶帖子
          
        
      
        

          

            

            

                def pin
          
        
      
        

          

            

            

                  authenticate_admin! and return
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  @post = Post.find(params[:id])
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 使用PostManagementService处理帖子置顶
          
        
      
        

          

            

            

                  service_result = PostManagementService.pin_post!(@post, current_user)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if service_result.success?
          
        
      
        

          

            

            

                    render json: service_result.result
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    render json: { error: service_result.first_error }, status: :forbidden
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # POST /api/posts/:id/unpin  # 取消置顶
          
        
      
        

          

            

            

                def unpin
          
        
      
        

          

            

            

                  authenticate_admin! and return
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  @post = Post.find(params[:id])
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  unless @post.can_pin?(current_user)
          
        
      
        

          

            

            

                    render json: { error: "无权限取消置顶此帖子" }, status: :forbidden
          
        
      
        

          

            

            

                    return
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  @post.unpin!
          
        
      
        

          

            

            

                  render json: {
          
        
      
        

          

            

            

                    message: "帖子已取消置顶",
          
        
      
        

          

            

            

                    post: @post.as_json
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # POST /api/posts/:id/hide  # 隐藏帖子
          
        
      
        

          

            

            

                def hide
          
        
      
        

          

            

            

                  authenticate_admin! and return
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  @post = Post.find(params[:id])
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  unless @post.can_hide?(current_user)
          
        
      
        

          

            

            

                    render json: { error: "无权限隐藏此帖子" }, status: :forbidden
          
        
      
        

          

            

            

                    return
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  @post.hide!
          
        
      
        

          

            

            

                  render json: {
          
        
      
        

          

            

            

                    message: "帖子已隐藏",
          
        
      
        

          

            

            

                    post: @post.as_json
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # POST /api/posts/:id/unhide  # 显示帖子
          
        
      
        

          

            

            

                def unhide
          
        
      
        

          

            

            

                  authenticate_admin! and return
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  @post = Post.find(params[:id])
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  unless @post.can_hide?(current_user)
          
        
      
        

          

            

            

                    render json: { error: "无权限显示此帖子" }, status: :forbidden
          
        
      
        

          

            

            

                    return
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  @post.unhide!
          
        
      
        

          

            

            

                  render json: {
          
        
      
        

          

            

            

                    message: "帖子已显示",
          
        
      
        

          

            

            

                    post: @post.as_json
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # POST /api/posts/:id/like  # 点赞帖子
          
        
      
        

          

            

            

                def like
          
        
      
        

          

            

            

                  @post = Post.find(params[:id])
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if Like.like!(current_user, @post)
          
        
      
        

          

            

            

                    render json: {
          
        
      
        

          

            

            

                      message: "点赞成功",
          
        
      
        

          

            

            

                      liked: true,
          
        
      
        

          

            

            

                      likes_count: @post.likes_count
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    render json: { error: "已经点赞过了" }, status: :unprocessable_entity
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # DELETE /api/posts/:id/like  # 取消点赞
          
        
      
        

          

            

            

                def unlike
          
        
      
        

          

            

            

                  @post = Post.find(params[:id])
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if Like.unlike!(current_user, @post)
          
        
      
        

          

            

            

                    render json: {
          
        
      
        

          

            

            

                      message: "取消点赞成功",
          
        
      
        

          

            

            

                      liked: false,
          
        
      
        

          

            

            

                      likes_count: @post.likes_count
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    render json: { error: "还未点赞" }, status: :unprocessable_entity
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                private
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                def post_params
          
        
      
        

          

            

            

                  params.require(:post).permit(:title, :content, :category, :images, tags: [])
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end
          
        
      
    
  

    

      
        

          

            

            

            module Api
          
        
      
        

          

            

            

              class UploadsController < Api::ApplicationController
          
        
      
        

          

            

            

                before_action :authenticate_user!
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # POST /api/upload/image
          
        
      
        

          

            

            

                def create
          
        
      
        

          

            

            

                  return render json: { error: '请选择图片文件' }, status: :bad_request unless params[:file]
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  uploaded_file = params[:file]
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 验证文件类型
          
        
      
        

          

            

            

                  unless uploaded_file.content_type.in?(['image/jpeg', 'image/jpg', 'image/png', 'image/gif'])
          
        
      
        

          

            

            

                    return render json: { error: '只支持 JPG、PNG、GIF 格式的图片' }, status: :bad_request
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # 验证文件大小（最大5MB）
          
        
      
        

          

            

            

                  if uploaded_file.size > 5.megabytes
          
        
      
        

          

            

            

                    return render json: { error: '图片大小不能超过5MB' }, status: :bad_request
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  begin
          
        
      
        

          

            

            

                    # 生成唯一文件名
          
        
      
        

          

            

            

                    file_name = "#{SecureRandom.uuid}_#{uploaded_file.original_filename}"
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                    # 这里应该将文件存储到云存储服务，如阿里云OSS、腾讯云COS等
          
        
      
        

          

            

            

                    # 暂时存储到本地，生产环境需要使用云存储
          
        
      
        

          

            

            

                    file_path = Rails.root.join('tmp', 'uploads', file_name)
          
        
      
        

          

            

            

                    FileUtils.mkdir_p(File.dirname(file_path))
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                    File.open(file_path, 'wb') do |file|
          
        
      
        

          

            

            

                      file.write(uploaded_file.read)
          
        
      
        

          

            

            

                    end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                    # 生成访问URL（开发环境使用本地路径）
          
        
      
        

          

            

            

                    url = "/uploads/#{file_name}"
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                    render json: {
          
        
      
        

          

            

            

                      message: '图片上传成功',
          
        
      
        

          

            

            

                      url: url,
          
        
      
        

          

            

            

                      file_name: file_name
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  rescue => e
          
        
      
        

          

            

            

                    Rails.logger.error "图片上传失败: #{e.message}"
          
        
      
        

          

            

            

                    render json: { error: '图片上传失败，请重试' }, status: :internal_server_error
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                private
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                def authenticate_user!
          
        
      
        

          

            

            

                  return head :unauthorized unless current_user
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end
          
        
      
    
  

    

      
        

          

            

            

            # frozen_string_literal: true
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            class Api::V1::AnalyticsController < ApplicationController
          
        
      
        

          

            

            

              before_action :authenticate_user!
          
        
      
        

          

            

            

              before_action :require_admin_for_system_analytics
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # GET /api/v1/analytics/overview
          
        
      
        

          

            

            

              # 获取系统总览统计（管理员）
          
        
      
        

          

            

            

              def overview
          
        
      
        

          

            

            

                render json: {
          
        
      
        

          

            

            

                  success: true,
          
        
      
        

          

            

            

                  data: AnalyticsService.system_overview,
          
        
      
        

          

            

            

                  generated_at: Time.current
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # GET /api/v1/analytics/dashboard
          
        
      
        

          

            

            

              # 获取用户仪表板数据
          
        
      
        

          

            

            

              def dashboard
          
        
      
        

          

            

            

                days = params[:days]&.to_i || 30
          
        
      
        

          

            

            

                user_analytics = AnalyticsService.user_analytics(current_user, days)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                render json: {
          
        
      
        

          

            

            

                  success: true,
          
        
      
        

          

            

            

                  data: user_analytics,
          
        
      
        

          

            

            

                  period: "#{days} 天",
          
        
      
        

          

            

            

                  generated_at: Time.current
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # GET /api/v1/analytics/events/:id
          
        
      
        

          

            

            

              # 获取活动详细统计
          
        
      
        

          

            

            

              def event_stats
          
        
      
        

          

            

            

                event = ReadingEvent.find(params[:id])
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # 检查权限：活动创建者、管理员或参与者可以查看统计
          
        
      
        

          

            

            

                unless can_view_event_analytics?(event)
          
        
      
        

          

            

            

                  return render json: {
          
        
      
        

          

            

            

                    success: false,
          
        
      
        

          

            

            

                    error: '无权限查看此活动统计'
          
        
      
        

          

            

            

                  }, status: :forbidden
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                analytics = AnalyticsService.event_analytics(event)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                render json: {
          
        
      
        

          

            

            

                  success: true,
          
        
      
        

          

            

            

                  data: analytics,
          
        
      
        

          

            

            

                  generated_at: Time.current
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # GET /api/v1/analytics/trends
          
        
      
        

          

            

            

              # 获取趋势数据
          
        
      
        

          

            

            

              def trends
          
        
      
        

          

            

            

                metric = params[:metric]&.to_sym
          
        
      
        

          

            

            

                period = params[:period]&.to_sym || :week
          
        
      
        

          

            

            

                days = params[:days]&.to_i || 30
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                unless [:check_ins, :flowers, :users, :events, :notifications].include?(metric)
          
        
      
        

          

            

            

                  return render json: {
          
        
      
        

          

            

            

                    success: false,
          
        
      
        

          

            

            

                    error: '无效的指标类型。支持的类型: check_ins, flowers, users, events, notifications'
          
        
      
        

          

            

            

                  }, status: :bad_request
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                unless [:day, :week, :month].include?(period)
          
        
      
        

          

            

            

                  return render json: {
          
        
      
        

          

            

            

                    success: false,
          
        
      
        

          

            

            

                    error: '无效的时间周期。支持的周期: day, week, month'
          
        
      
        

          

            

            

                  }, status: :bad_request
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                trend_data = AnalyticsService.trend_data(metric, period, days)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                render json: {
          
        
      
        

          

            

            

                  success: true,
          
        
      
        

          

            

            

                  metric: metric,
          
        
      
        

          

            

            

                  period: period,
          
        
      
        

          

            

            

                  days: days,
          
        
      
        

          

            

            

                  data: trend_data,
          
        
      
        

          

            

            

                  generated_at: Time.current
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # GET /api/v1/analytics/leaderboards
          
        
      
        

          

            

            

              # 获取排行榜数据
          
        
      
        

          

            

            

              def leaderboards
          
        
      
        

          

            

            

                type = params[:type]&.to_sym || :flowers
          
        
      
        

          

            

            

                limit = params[:limit]&.to_i || 10
          
        
      
        

          

            

            

                period = params[:period]&.to_sym || :all_time
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                unless [:flowers, :check_ins, :participation].include?(type)
          
        
      
        

          

            

            

                  return render json: {
          
        
      
        

          

            

            

                    success: false,
          
        
      
        

          

            

            

                    error: '无效的排行榜类型。支持的类型: flowers, check_ins, participation'
          
        
      
        

          

            

            

                  }, status: :bad_request
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                unless [:today, :week, :month, :all_time].include?(period)
          
        
      
        

          

            

            

                  return render json: {
          
        
      
        

          

            

            

                    success: false,
          
        
      
        

          

            

            

                    error: '无效的时间周期。支持的周期: today, week, month, all_time'
          
        
      
        

          

            

            

                  }, status: :bad_request
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                leaderboard_data = AnalyticsService.leaderboards(type, limit, period)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                render json: {
          
        
      
        

          

            

            

                  success: true,
          
        
      
        

          

            

            

                  type: type,
          
        
      
        

          

            

            

                  period: period,
          
        
      
        

          

            

            

                  limit: limit,
          
        
      
        

          

            

            

                  data: leaderboard_data,
          
        
      
        

          

            

            

                  generated_at: Time.current
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # GET /api/v1/analytics/users/:id
          
        
      
        

          

            

            

              # 获取用户详细统计（管理员功能）
          
        
      
        

          

            

            

              def user_stats
          
        
      
        

          

            

            

                user = User.find(params[:id])
          
        
      
        

          

            

            

                days = params[:days]&.to_i || 30
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                unless current_user.any_admin? || current_user.id == user.id
          
        
      
        

          

            

            

                  return render json: {
          
        
      
        

          

            

            

                    success: false,
          
        
      
        

          

            

            

                    error: '无权限查看此用户统计'
          
        
      
        

          

            

            

                  }, status: :forbidden
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                analytics = AnalyticsService.user_analytics(user, days)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                render json: {
          
        
      
        

          

            

            

                  success: true,
          
        
      
        

          

            

            

                  data: analytics,
          
        
      
        

          

            

            

                  period: "#{days} 天",
          
        
      
        

          

            

            

                  generated_at: Time.current
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # GET /api/v1/analytics/summary
          
        
      
        

          

            

            

              # 获取简化的统计数据摘要
          
        
      
        

          

            

            

              def summary
          
        
      
        

          

            

            

                summary_data = {
          
        
      
        

          

            

            

                  system: {
          
        
      
        

          

            

            

                    total_users: User.count,
          
        
      
        

          

            

            

                    active_events: ReadingEvent.where(status: ['enrolling', 'in_progress']).count,
          
        
      
        

          

            

            

                    today_check_ins: CheckIn.where('created_at >= ?', Date.current).count,
          
        
      
        

          

            

            

                    today_flowers: Flower.where('created_at >= ?', Date.current).count
          
        
      
        

          

            

            

                  },
          
        
      
        

          

            

            

                  user: {
          
        
      
        

          

            

            

                    enrolled_events: current_user.event_enrollments.where(status: 'enrolled').count,
          
        
      
        

          

            

            

                    my_check_ins: current_user.check_ins.where('created_at >= ?', 7.days.ago).count,
          
        
      
        

          

            

            

                    flowers_received: current_user.received_flowers.where('created_at >= ?', 7.days.ago).count,
          
        
      
        

          

            

            

                    notifications_unread: current_user.received_notifications.unread.count
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                render json: {
          
        
      
        

          

            

            

                  success: true,
          
        
      
        

          

            

            

                  data: summary_data,
          
        
      
        

          

            

            

                  generated_at: Time.current
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # GET /api/v1/analytics/reports
          
        
      
        

          

            

            

              # 生成报告（管理员功能）
          
        
      
        

          

            

            

              def reports
          
        
      
        

          

            

            

                report_type = params[:type]&.to_sym
          
        
      
        

          

            

            

                format = params[:format]&.to_sym || :json
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                unless current_user.any_admin?
          
        
      
        

          

            

            

                  return render json: {
          
        
      
        

          

            

            

                    success: false,
          
        
      
        

          

            

            

                    error: '需要管理员权限'
          
        
      
        

          

            

            

                  }, status: :forbidden
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                case report_type
          
        
      
        

          

            

            

                when :monthly
          
        
      
        

          

            

            

                  report = generate_monthly_report
          
        
      
        

          

            

            

                when :activity
          
        
      
        

          

            

            

                  report = generate_activity_report
          
        
      
        

          

            

            

                when :engagement
          
        
      
        

          

            

            

                  report = generate_engagement_report
          
        
      
        

          

            

            

                else
          
        
      
        

          

            

            

                  return render json: {
          
        
      
        

          

            

            

                    success: false,
          
        
      
        

          

            

            

                    error: '无效的报告类型。支持的类型: monthly, activity, engagement'
          
        
      
        

          

            

            

                  }, status: :bad_request
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                render json: {
          
        
      
        

          

            

            

                  success: true,
          
        
      
        

          

            

            

                  report_type: report_type,
          
        
      
        

          

            

            

                  data: report,
          
        
      
        

          

            

            

                  generated_at: Time.current
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # GET /api/v1/analytics/export
          
        
      
        

          

            

            

              # 导出数据（管理员功能）
          
        
      
        

          

            

            

              def export
          
        
      
        

          

            

            

                export_type = params[:type]&.to_sym
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                unless current_user.any_admin?
          
        
      
        

          

            

            

                  return render json: {
          
        
      
        

          

            

            

                    success: false,
          
        
      
        

          

            

            

                    error: '需要管理员权限'
          
        
      
        

          

            

            

                  }, status: :forbidden
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                case export_type
          
        
      
        

          

            

            

                when :users
          
        
      
        

          

            

            

                  data = export_users_data
          
        
      
        

          

            

            

                when :events
          
        
      
        

          

            

            

                  data = export_events_data
          
        
      
        

          

            

            

                when :flowers
          
        
      
        

          

            

            

                  data = export_flowers_data
          
        
      
        

          

            

            

                else
          
        
      
        

          

            

            

                  return render json: {
          
        
      
        

          

            

            

                    success: false,
          
        
      
        

          

            

            

                    error: '无效的导出类型。支持的类型: users, events, flowers'
          
        
      
        

          

            

            

                  }, status: :bad_request
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                render json: {
          
        
      
        

          

            

            

                  success: true,
          
        
      
        

          

            

            

                  export_type: export_type,
          
        
      
        

          

            

            

                  data: data,
          
        
      
        

          

            

            

                  record_count: data.count,
          
        
      
        

          

            

            

                  generated_at: Time.current
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              private
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # 检查是否为系统分析需要管理员权限
          
        
      
        

          

            

            

              def require_admin_for_system_analytics
          
        
      
        

          

            

            

                return unless [:overview, :reports, :export].include?(action_name.to_sym)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                unless current_user.any_admin?
          
        
      
        

          

            

            

                  render json: {
          
        
      
        

          

            

            

                    success: false,
          
        
      
        

          

            

            

                    error: '需要管理员权限'
          
        
      
        

          

            

            

                  }, status: :forbidden
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # 检查是否可以查看活动分析
          
        
      
        

          

            

            

              def can_view_event_analytics?(event)
          
        
      
        

          

            

            

                return true if current_user.any_admin?
          
        
      
        

          

            

            

                return true if event.leader_id == current_user.id
          
        
      
        

          

            

            

                return true if event.participants.include?(current_user)
          
        
      
        

          

            

            

                false
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # 生成月度报告
          
        
      
        

          

            

            

              def generate_monthly_report
          
        
      
        

          

            

            

                current_month = Date.current.beginning_of_month
          
        
      
        

          

            

            

                last_month = current_month - 1.month
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  current_month: {
          
        
      
        

          

            

            

                    period: current_month.strftime('%Y年%m月'),
          
        
      
        

          

            

            

                    users: {
          
        
      
        

          

            

            

                      new: User.where(created_at: current_month..(current_month + 1.month)).count,
          
        
      
        

          

            

            

                      active: active_users_in_period(current_month, (current_month + 1.month))
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    events: {
          
        
      
        

          

            

            

                      created: ReadingEvent.where(created_at: current_month..(current_month + 1.month)).count,
          
        
      
        

          

            

            

                      completed: ReadingEvent.where(status: 'completed', updated_at: current_month..(current_month + 1.month)).count
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    engagement: {
          
        
      
        

          

            

            

                      check_ins: CheckIn.where(created_at: current_month..(current_month + 1.month)).count,
          
        
      
        

          

            

            

                      flowers: Flower.where(created_at: current_month..(current_month + 1.month)).count
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  },
          
        
      
        

          

            

            

                  comparison: {
          
        
      
        

          

            

            

                    period: last_month.strftime('%Y年%m月'),
          
        
      
        

          

            

            

                    user_growth: calculate_growth_rate(
          
        
      
        

          

            

            

                      User.where(created_at: last_month..current_month).count,
          
        
      
        

          

            

            

                      User.where(created_at: (last_month - 1.month)..last_month).count
          
        
      
        

          

            

            

                    ),
          
        
      
        

          

            

            

                    engagement_growth: calculate_growth_rate(
          
        
      
        

          

            

            

                      CheckIn.where(created_at: current_month..(current_month + 1.month)).count,
          
        
      
        

          

            

            

                      CheckIn.where(created_at: last_month..current_month).count
          
        
      
        

          

            

            

                    )
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # 生成活动报告
          
        
      
        

          

            

            

              def generate_activity_report
          
        
      
        

          

            

            

                status = params[:status] || 'all'
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                events = ReadingEvent.all
          
        
      
        

          

            

            

                events = events.where(status: status) if status != 'all'
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                events.map do |event|
          
        
      
        

          

            

            

                  {
          
        
      
        

          

            

            

                    id: event.id,
          
        
      
        

          

            

            

                    title: event.title,
          
        
      
        

          

            

            

                    status: event.status,
          
        
      
        

          

            

            

                    participants_count: event.event_enrollments.where(status: 'enrolled').count,
          
        
      
        

          

            

            

                    check_ins_count: event.check_ins.count,
          
        
      
        

          

            

            

                    flowers_count: event.flowers_count,
          
        
      
        

          

            

            

                    completion_rate: AnalyticsService.send(:calculate_event_completion_rate, event.event_enrollments),
          
        
      
        

          

            

            

                    engagement_score: AnalyticsService.send(:calculate_event_engagement_score, event)
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # 生成参与度报告
          
        
      
        

          

            

            

              def generate_engagement_report
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  user_engagement: user_engagement_metrics,
          
        
      
        

          

            

            

                  event_engagement: event_engagement_metrics,
          
        
      
        

          

            

            

                  daily_activity: daily_activity_metrics,
          
        
      
        

          

            

            

                  trends: engagement_trends
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # 导出用户数据
          
        
      
        

          

            

            

              def export_users_data
          
        
      
        

          

            

            

                User.all.map do |user|
          
        
      
        

          

            

            

                  {
          
        
      
        

          

            

            

                    id: user.id,
          
        
      
        

          

            

            

                    nickname: user.nickname,
          
        
      
        

          

            

            

                    wx_openid: user.wx_openid,
          
        
      
        

          

            

            

                    role: user.role_as_string,
          
        
      
        

          

            

            

                    created_at: user.created_at,
          
        
      
        

          

            

            

                    last_activity: user.check_ins.maximum(:created_at) || user.created_at,
          
        
      
        

          

            

            

                    events_count: user.event_enrollments.count,
          
        
      
        

          

            

            

                    check_ins_count: user.check_ins.count,
          
        
      
        

          

            

            

                    flowers_given: user.given_flowers.count,
          
        
      
        

          

            

            

                    flowers_received: user.received_flowers.count
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # 导出活动数据
          
        
      
        

          

            

            

              def export_events_data
          
        
      
        

          

            

            

                ReadingEvent.all.map do |event|
          
        
      
        

          

            

            

                  {
          
        
      
        

          

            

            

                    id: event.id,
          
        
      
        

          

            

            

                    title: event.title,
          
        
      
        

          

            

            

                    book_name: event.book_name,
          
        
      
        

          

            

            

                    leader: event.leader&.nickname,
          
        
      
        

          

            

            

                    status: event.status,
          
        
      
        

          

            

            

                    approval_status: event.approval_status,
          
        
      
        

          

            

            

                    start_date: event.start_date,
          
        
      
        

          

            

            

                    end_date: event.end_date,
          
        
      
        

          

            

            

                    max_participants: event.max_participants,
          
        
      
        

          

            

            

                    enrolled_count: event.event_enrollments.where(status: 'enrolled').count,
          
        
      
        

          

            

            

                    check_ins_count: event.check_ins.count,
          
        
      
        

          

            

            

                    flowers_count: event.flowers_count,
          
        
      
        

          

            

            

                    created_at: event.created_at
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # 导出小红花数据
          
        
      
        

          

            

            

              def export_flowers_data
          
        
      
        

          

            

            

                Flower.includes(:giver, :recipient, :check_in).all.map do |flower|
          
        
      
        

          

            

            

                  {
          
        
      
        

          

            

            

                    id: flower.id,
          
        
      
        

          

            

            

                    giver: flower.giver&.nickname,
          
        
      
        

          

            

            

                    recipient: flower.recipient&.nickname,
          
        
      
        

          

            

            

                    check_in_content: flower.check_in&.content&.truncate(50),
          
        
      
        

          

            

            

                    amount: flower.amount,
          
        
      
        

          

            

            

                    flower_type: flower.flower_type,
          
        
      
        

          

            

            

                    comment: flower.comment,
          
        
      
        

          

            

            

                    created_at: flower.created_at
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # 辅助方法
          
        
      
        

          

            

            

              def active_users_in_period(start_time, end_time)
          
        
      
        

          

            

            

                User.joins(:check_ins)
          
        
      
        

          

            

            

                    .where('check_ins.created_at >= ? AND check_ins.created_at < ?', start_time, end_time)
          
        
      
        

          

            

            

                    .distinct
          
        
      
        

          

            

            

                    .count
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              def calculate_growth_rate(current, previous)
          
        
      
        

          

            

            

                return 0 if previous == 0
          
        
      
        

          

            

            

                ((current - previous).to_f / previous * 100).round(2)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              def user_engagement_metrics
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  average_check_ins_per_user: CheckIn.count.to_f / [User.count, 1].max,
          
        
      
        

          

            

            

                  average_flowers_per_user: Flower.count.to_f / [User.count, 1].max,
          
        
      
        

          

            

            

                  user_retention_rate: AnalyticsService.send(:user_retention_rate)
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              def event_engagement_metrics
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  average_participation_rate: calculate_average_participation_rate,
          
        
      
        

          

            

            

                  average_completion_rate: calculate_average_completion_rate,
          
        
      
        

          

            

            

                  most_active_events: most_active_events(5)
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              def daily_activity_metrics
          
        
      
        

          

            

            

                (7.days.ago.to_date..Date.current).map do |date|
          
        
      
        

          

            

            

                  {
          
        
      
        

          

            

            

                    date: date.strftime('%Y-%m-%d'),
          
        
      
        

          

            

            

                    check_ins: CheckIn.where(created_at: date.beginning_of_day..date.end_of_day).count,
          
        
      
        

          

            

            

                    flowers: Flower.where(created_at: date.beginning_of_day..date.end_of_day).count,
          
        
      
        

          

            

            

                    active_users: active_users_in_period(date.beginning_of_day, date.end_of_day)
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              def engagement_trends
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  check_ins_trend: AnalyticsService.trend_data(:check_ins, :week, 30),
          
        
      
        

          

            

            

                  flowers_trend: AnalyticsService.trend_data(:flowers, :week, 30),
          
        
      
        

          

            

            

                  users_trend: AnalyticsService.trend_data(:users, :week, 30)
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              def calculate_average_participation_rate
          
        
      
        

          

            

            

                total_events = ReadingEvent.where(status: ['enrolling', 'in_progress', 'completed']).count
          
        
      
        

          

            

            

                return 0 if total_events == 0
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                total_capacity = ReadingEvent.where(status: ['enrolling', 'in_progress', 'completed'])
          
        
      
        

          

            

            

                                         .sum(:max_participants)
          
        
      
        

          

            

            

                total_enrolled = ReadingEvent.joins(:event_enrollments)
          
        
      
        

          

            

            

                                             .where(event_enrollments: { status: 'enrolled' })
          
        
      
        

          

            

            

                                             .count
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                (total_enrolled.to_f / total_capacity * 100).round(2)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              def calculate_average_completion_rate
          
        
      
        

          

            

            

                completed_enrollments = EventEnrollment.where(status: 'completed').count
          
        
      
        

          

            

            

                total_enrollments = EventEnrollment.where.not(status: 'cancelled').count
          
        
      
        

          

            

            

                return 0 if total_enrollments == 0
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                (completed_enrollments.to_f / total_enrollments * 100).round(2)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              def most_active_events(limit = 5)
          
        
      
        

          

            

            

                ReadingEvent.joins(:check_ins)
          
        
      
        

          

            

            

                            .group('reading_events.id')
          
        
      
        

          

            

            

                            .select('reading_events.*, COUNT(check_ins.id) as check_ins_count')
          
        
      
        

          

            

            

                            .order('check_ins_count DESC')
          
        
      
        

          

            

            

                            .limit(limit)
          
        
      
        

          

            

            

                            .map do |event|
          
        
      
        

          

            

            

                              {
          
        
      
        

          

            

            

                                id: event.id,
          
        
      
        

          

            

            

                                title: event.title,
          
        
      
        

          

            

            

                                check_ins_count: event.check_ins_count,
          
        
      
        

          

            

            

                                flowers_count: event.flowers_count
          
        
      
        

          

            

            

                              }
          
        
      
        

          

            

            

                            end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end